{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Road_sign_detection.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPRgIcco9JLw0/MN/P+LT1O",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PacktPublishing/Modern-Computer-Vision-with-PyTorch/blob/master/Chapter06/Road_sign_detection.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LFTmB5VM1rp6",
        "outputId": "26c5428d-c367-4515-d666-9d8d6df4aedd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 276
        }
      },
      "source": [
        "import os\n",
        "if not os.path.exists('GTSRB'):\n",
        "    !pip install -U -q torch_snippets\n",
        "    !wget -qq https://sid.erda.dk/public/archives/daaeac0d7ce1152aea9b61d9f1e19370/GTSRB_Final_Training_Images.zip\n",
        "    !wget -qq https://sid.erda.dk/public/archives/daaeac0d7ce1152aea9b61d9f1e19370/GTSRB_Final_Test_Images.zip\n",
        "    !unzip -qq GTSRB_Final_Training_Images.zip\n",
        "    !unzip -qq GTSRB_Final_Test_Images.zip\n",
        "    !wget https://raw.githubusercontent.com/georgesung/traffic_sign_classification_german/master/signnames.csv\n",
        "    !rm GTSRB_Final_Training_Images.zip GTSRB_Final_Test_Images.zip\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[K     |████████████████████████████████| 61kB 2.2MB/s \n",
            "\u001b[K     |████████████████████████████████| 36.6MB 86kB/s \n",
            "\u001b[K     |████████████████████████████████| 102kB 14.0MB/s \n",
            "\u001b[?25h  Building wheel for contextvars (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "--2020-09-17 11:22:17--  https://raw.githubusercontent.com/georgesung/traffic_sign_classification_german/master/signnames.csv\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.0.133, 151.101.64.133, 151.101.128.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.0.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 999 [text/plain]\n",
            "Saving to: ‘signnames.csv’\n",
            "\n",
            "signnames.csv       100%[===================>]     999  --.-KB/s    in 0s      \n",
            "\n",
            "2020-09-17 11:22:18 (72.4 MB/s) - ‘signnames.csv’ saved [999/999]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7a8ctbvs0jEp",
        "outputId": "c8024cc6-342b-41bc-c1f2-537b4894cd2e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        }
      },
      "source": [
        "from torch_snippets import *\n",
        "classIds = pd.read_csv('signnames.csv')\n",
        "classIds.set_index('ClassId', inplace=True)\n",
        "classIds = classIds.to_dict()['SignName']\n",
        "classIds = {f'{k:05d}':v for k,v in classIds.items()}\n",
        "id2int = {v:ix for ix,(k,v) in enumerate(classIds.items())}\n",
        "\n",
        "from torchvision import transforms as T\n",
        "classIds = pd.read_csv('signnames.csv')\n",
        "classIds.set_index('ClassId', inplace=True)\n",
        "classIds = classIds.to_dict()['SignName']\n",
        "classIds = {f'{k:05d}':v for k,v in classIds.items()}\n",
        "id2int = {v:ix for ix,(k,v) in enumerate(classIds.items())}\n",
        "\n",
        "from torchvision import transforms as T\n",
        "\n",
        "trn_tfms = T.Compose([\n",
        "    T.ToPILImage(),\n",
        "    T.Resize(32),\n",
        "    T.CenterCrop(32),\n",
        "    # T.ColorJitter(brightness=(0.8,1.2), \n",
        "    # contrast=(0.8,1.2), \n",
        "    # saturation=(0.8,1.2), \n",
        "    # hue=0.25),\n",
        "    # T.RandomAffine(5, translate=(0.01,0.1)),\n",
        "    T.ToTensor(),\n",
        "    T.Normalize(mean=[0.485, 0.456, 0.406], \n",
        "                std=[0.229, 0.224, 0.225]),\n",
        "])\n",
        "\n",
        "val_tfms = T.Compose([\n",
        "    T.ToPILImage(),\n",
        "    T.Resize(32),\n",
        "    T.CenterCrop(32),\n",
        "    T.ToTensor(),\n",
        "    T.Normalize(mean=[0.485, 0.456, 0.406], \n",
        "                std=[0.229, 0.224, 0.225]),\n",
        "])\n",
        "\n",
        "class GTSRB(Dataset):\n",
        "    \"\"\"Face Landmarks dataset.\"\"\"\n",
        "\n",
        "    def __init__(self, files, transform=None):\n",
        "        self.files = files\n",
        "        self.transform = transform\n",
        "        logger.info(len(self))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.files)\n",
        "\n",
        "    def __getitem__(self, ix):\n",
        "        fpath = self.files[ix]\n",
        "        clss = fname(parent(fpath))\n",
        "        img = read(fpath, 1)\n",
        "        return img, classIds[clss]\n",
        "\n",
        "    def choose(self):\n",
        "        return self[randint(len(self))]\n",
        "\n",
        "    def collate_fn(self, batch):\n",
        "        imgs, classes = list(zip(*batch))\n",
        "        if self.transform:\n",
        "            imgs = [self.transform(img)[None] for img in imgs]\n",
        "        classes = [torch.tensor([id2int[clss]]) for clss in classes]\n",
        "        imgs, classes = [torch.cat(i).to(device) for i in [imgs, classes]]\n",
        "        return imgs, classes\n",
        "\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "all_files = Glob('GTSRB/Final_Training/Images/*/*.ppm')\n",
        "np.random.seed(10)\n",
        "np.random.shuffle(all_files)\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "trn_files, val_files = train_test_split(all_files, random_state=1)\n",
        "\n",
        "trn_ds = GTSRB(trn_files, transform=trn_tfms)\n",
        "val_ds = GTSRB(val_files, transform=val_tfms)\n",
        "trn_dl = DataLoader(trn_ds, 32, shuffle=True, collate_fn=trn_ds.collate_fn)\n",
        "val_dl = DataLoader(val_ds, 32, shuffle=False, collate_fn=val_ds.collate_fn)\n",
        "\n",
        "import torchvision.models as models\n",
        "\n",
        "def convBlock(ni, no):\n",
        "    return nn.Sequential(\n",
        "        nn.Dropout(0.2),\n",
        "        nn.Conv2d(ni, no, kernel_size=3, padding=1),\n",
        "        nn.ReLU(inplace=True),\n",
        "        #nn.BatchNorm2d(no),\n",
        "        nn.MaxPool2d(2),\n",
        "    )\n",
        "    \n",
        "class SignClassifier(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.model = nn.Sequential(\n",
        "            convBlock(3, 64),\n",
        "            convBlock(64, 64),\n",
        "            convBlock(64, 128),\n",
        "            convBlock(128, 64),\n",
        "            nn.Flatten(),\n",
        "            nn.Linear(256, 256),\n",
        "            nn.Dropout(0.2),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Linear(256, len(id2int))\n",
        "        )\n",
        "        self.loss_fn = nn.CrossEntropyLoss()\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.model(x)\n",
        "\n",
        "    def compute_metrics(self, preds, targets):\n",
        "        ce_loss = self.loss_fn(preds, targets)\n",
        "        acc = (torch.max(preds, 1)[1] == targets).float().mean()\n",
        "        return ce_loss, acc\n",
        "def train_batch(model, data, optimizer, criterion):\n",
        "    ims, labels = data\n",
        "    _preds = model(ims)\n",
        "    optimizer.zero_grad()\n",
        "    loss, acc = criterion(_preds, labels)\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "    return loss.item(), acc.item()\n",
        "\n",
        "@torch.no_grad()\n",
        "def validate_batch(model, data, criterion):\n",
        "    ims, labels = data\n",
        "    _preds = model(ims)\n",
        "    loss, acc = criterion(_preds, labels)\n",
        "    return loss.item(), acc.item()\n",
        "model = SignClassifier().to(device)\n",
        "criterion = model.compute_metrics\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "n_epochs = 40\n",
        "\n",
        "log = Report(n_epochs)\n",
        "for ex in range(n_epochs):\n",
        "    N = len(trn_dl)\n",
        "    for bx, data in enumerate(trn_dl):\n",
        "        loss, acc = train_batch(model, data, optimizer, criterion)\n",
        "        log.record(ex+(bx+1)/N, trn_loss=loss, trn_acc=acc, end='\\r')\n",
        "\n",
        "    N = len(val_dl)\n",
        "    for bx, data in enumerate(val_dl):\n",
        "        loss, acc = validate_batch(model, data, criterion)\n",
        "        log.record(ex+(bx+1)/N, val_loss=loss, val_acc=acc, end='\\r')\n",
        "        \n",
        "    log.report_avgs(ex+1)\n",
        "    if ex == 10: optimizer = optim.Adam(model.parameters(), lr=1e-4)\n",
        "\n",
        "log.plot_epochs()\n",
        "dumpdill(log, 'no-aug-no-bn.log')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020-09-17 11:22:22.120 | INFO     | torch_snippets.loader:Glob:172 - 39209 files found at GTSRB/Final_Training/Images/*/*.ppm\n",
            "2020-09-17 11:22:22.509 | INFO     | __main__:__init__:46 - 29406\n",
            "2020-09-17 11:22:22.510 | INFO     | __main__:__init__:46 - 9803\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 1.000\ttrn_loss: 2.410\ttrn_acc: 0.290\tval_loss: 1.641\tval_acc: 0.475\t(17.64s - 688.04s remaining)\n",
            "EPOCH: 2.000\ttrn_loss: 1.214\ttrn_acc: 0.599\tval_loss: 0.914\tval_acc: 0.695\t(34.74s - 660.13s remaining)\n",
            "EPOCH: 2.610\ttrn_loss: 0.927\ttrn_acc: 0.625\t(42.70s - 611.66s remaining)"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jcW7H6v63Zp_"
      },
      "source": [
        "from torch_snippets import *\n",
        "classIds = pd.read_csv('signnames.csv')\n",
        "classIds.set_index('ClassId', inplace=True)\n",
        "classIds = classIds.to_dict()['SignName']\n",
        "classIds = {f'{k:05d}':v for k,v in classIds.items()}\n",
        "id2int = {v:ix for ix,(k,v) in enumerate(classIds.items())}\n",
        "\n",
        "from torchvision import transforms as T\n",
        "classIds = pd.read_csv('signnames.csv')\n",
        "classIds.set_index('ClassId', inplace=True)\n",
        "classIds = classIds.to_dict()['SignName']\n",
        "classIds = {f'{k:05d}':v for k,v in classIds.items()}\n",
        "id2int = {v:ix for ix,(k,v) in enumerate(classIds.items())}\n",
        "\n",
        "from torchvision import transforms as T\n",
        "\n",
        "trn_tfms = T.Compose([\n",
        "    T.ToPILImage(),\n",
        "    T.Resize(32),\n",
        "    T.CenterCrop(32),\n",
        "    # T.ColorJitter(brightness=(0.8,1.2), \n",
        "    # contrast=(0.8,1.2), \n",
        "    # saturation=(0.8,1.2), \n",
        "    # hue=0.25),\n",
        "    # T.RandomAffine(5, translate=(0.01,0.1)),\n",
        "    T.ToTensor(),\n",
        "    T.Normalize(mean=[0.485, 0.456, 0.406], \n",
        "                std=[0.229, 0.224, 0.225]),\n",
        "])\n",
        "\n",
        "val_tfms = T.Compose([\n",
        "    T.ToPILImage(),\n",
        "    T.Resize(32),\n",
        "    T.CenterCrop(32),\n",
        "    T.ToTensor(),\n",
        "    T.Normalize(mean=[0.485, 0.456, 0.406], \n",
        "                std=[0.229, 0.224, 0.225]),\n",
        "])\n",
        "\n",
        "class GTSRB(Dataset):\n",
        "    \"\"\"Face Landmarks dataset.\"\"\"\n",
        "\n",
        "    def __init__(self, files, transform=None):\n",
        "        self.files = files\n",
        "        self.transform = transform\n",
        "        logger.info(len(self))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.files)\n",
        "\n",
        "    def __getitem__(self, ix):\n",
        "        fpath = self.files[ix]\n",
        "        clss = fname(parent(fpath))\n",
        "        img = read(fpath, 1)\n",
        "        return img, classIds[clss]\n",
        "\n",
        "    def choose(self):\n",
        "        return self[randint(len(self))]\n",
        "\n",
        "    def collate_fn(self, batch):\n",
        "        imgs, classes = list(zip(*batch))\n",
        "        if self.transform:\n",
        "            imgs = [self.transform(img)[None] for img in imgs]\n",
        "        classes = [torch.tensor([id2int[clss]]) for clss in classes]\n",
        "        imgs, classes = [torch.cat(i).to(device) for i in [imgs, classes]]\n",
        "        return imgs, classes\n",
        "\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "all_files = Glob('GTSRB/Final_Training/Images/*/*.ppm')\n",
        "np.random.seed(10)\n",
        "np.random.shuffle(all_files)\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "trn_files, val_files = train_test_split(all_files, random_state=1)\n",
        "\n",
        "trn_ds = GTSRB(trn_files, transform=trn_tfms)\n",
        "val_ds = GTSRB(val_files, transform=val_tfms)\n",
        "trn_dl = DataLoader(trn_ds, 32, shuffle=True, collate_fn=trn_ds.collate_fn)\n",
        "val_dl = DataLoader(val_ds, 32, shuffle=False, collate_fn=val_ds.collate_fn)\n",
        "\n",
        "import torchvision.models as models\n",
        "\n",
        "def convBlock(ni, no):\n",
        "    return nn.Sequential(\n",
        "        nn.Dropout(0.2),\n",
        "        nn.Conv2d(ni, no, kernel_size=3, padding=1),\n",
        "        nn.ReLU(inplace=True),\n",
        "        nn.BatchNorm2d(no),\n",
        "        nn.MaxPool2d(2),\n",
        "    )\n",
        "    \n",
        "class SignClassifier(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.model = nn.Sequential(\n",
        "            convBlock(3, 64),\n",
        "            convBlock(64, 64),\n",
        "            convBlock(64, 128),\n",
        "            convBlock(128, 64),\n",
        "            nn.Flatten(),\n",
        "            nn.Linear(256, 256),\n",
        "            nn.Dropout(0.2),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Linear(256, len(id2int))\n",
        "        )\n",
        "        self.loss_fn = nn.CrossEntropyLoss()\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.model(x)\n",
        "\n",
        "    def compute_metrics(self, preds, targets):\n",
        "        ce_loss = self.loss_fn(preds, targets)\n",
        "        acc = (torch.max(preds, 1)[1] == targets).float().mean()\n",
        "        return ce_loss, acc\n",
        "def train_batch(model, data, optimizer, criterion):\n",
        "    ims, labels = data\n",
        "    _preds = model(ims)\n",
        "    optimizer.zero_grad()\n",
        "    loss, acc = criterion(_preds, labels)\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "    return loss.item(), acc.item()\n",
        "\n",
        "@torch.no_grad()\n",
        "def validate_batch(model, data, criterion):\n",
        "    ims, labels = data\n",
        "    _preds = model(ims)\n",
        "    loss, acc = criterion(_preds, labels)\n",
        "    return loss.item(), acc.item()\n",
        "model = SignClassifier().to(device)\n",
        "criterion = model.compute_metrics\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "n_epochs = 40\n",
        "\n",
        "log = Report(n_epochs)\n",
        "for ex in range(n_epochs):\n",
        "    N = len(trn_dl)\n",
        "    for bx, data in enumerate(trn_dl):\n",
        "        loss, acc = train_batch(model, data, optimizer, criterion)\n",
        "        log.record(ex+(bx+1)/N, trn_loss=loss, trn_acc=acc, end='\\r')\n",
        "\n",
        "    N = len(val_dl)\n",
        "    for bx, data in enumerate(val_dl):\n",
        "        loss, acc = validate_batch(model, data, criterion)\n",
        "        log.record(ex+(bx+1)/N, val_loss=loss, val_acc=acc, end='\\r')\n",
        "        \n",
        "    log.report_avgs(ex+1)\n",
        "    if ex == 10: optimizer = optim.Adam(model.parameters(), lr=1e-4)\n",
        "\n",
        "log.plot_epochs()\n",
        "dumpdill(log, 'no-aug-yes-bn.log')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tzJe_92X3wRG",
        "outputId": "3dc3ce9d-6e28-4924-ba1e-5664915e4a3c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 743
        }
      },
      "source": [
        "from torch_snippets import *\n",
        "classIds = pd.read_csv('signnames.csv')\n",
        "classIds.set_index('ClassId', inplace=True)\n",
        "classIds = classIds.to_dict()['SignName']\n",
        "classIds = {f'{k:05d}':v for k,v in classIds.items()}\n",
        "id2int = {v:ix for ix,(k,v) in enumerate(classIds.items())}\n",
        "\n",
        "from torchvision import transforms as T\n",
        "classIds = pd.read_csv('signnames.csv')\n",
        "classIds.set_index('ClassId', inplace=True)\n",
        "classIds = classIds.to_dict()['SignName']\n",
        "classIds = {f'{k:05d}':v for k,v in classIds.items()}\n",
        "id2int = {v:ix for ix,(k,v) in enumerate(classIds.items())}\n",
        "\n",
        "from torchvision import transforms as T\n",
        "\n",
        "trn_tfms = T.Compose([\n",
        "    T.ToPILImage(),\n",
        "    T.Resize(32),\n",
        "    T.CenterCrop(32),\n",
        "    T.ColorJitter(brightness=(0.8,1.2), \n",
        "    contrast=(0.8,1.2), \n",
        "    saturation=(0.8,1.2), \n",
        "    hue=0.25),\n",
        "    T.RandomAffine(5, translate=(0.01,0.1)),\n",
        "    T.ToTensor(),\n",
        "    T.Normalize(mean=[0.485, 0.456, 0.406], \n",
        "                std=[0.229, 0.224, 0.225]),\n",
        "])\n",
        "\n",
        "val_tfms = T.Compose([\n",
        "    T.ToPILImage(),\n",
        "    T.Resize(32),\n",
        "    T.CenterCrop(32),\n",
        "    T.ToTensor(),\n",
        "    T.Normalize(mean=[0.485, 0.456, 0.406], \n",
        "                std=[0.229, 0.224, 0.225]),\n",
        "])\n",
        "\n",
        "class GTSRB(Dataset):\n",
        "    \"\"\"Face Landmarks dataset.\"\"\"\n",
        "\n",
        "    def __init__(self, files, transform=None):\n",
        "        self.files = files\n",
        "        self.transform = transform\n",
        "        logger.info(len(self))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.files)\n",
        "\n",
        "    def __getitem__(self, ix):\n",
        "        fpath = self.files[ix]\n",
        "        clss = fname(parent(fpath))\n",
        "        img = read(fpath, 1)\n",
        "        return img, classIds[clss]\n",
        "\n",
        "    def choose(self):\n",
        "        return self[randint(len(self))]\n",
        "\n",
        "    def collate_fn(self, batch):\n",
        "        imgs, classes = list(zip(*batch))\n",
        "        if self.transform:\n",
        "            imgs = [self.transform(img)[None] for img in imgs]\n",
        "        classes = [torch.tensor([id2int[clss]]) for clss in classes]\n",
        "        imgs, classes = [torch.cat(i).to(device) for i in [imgs, classes]]\n",
        "        return imgs, classes\n",
        "\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "all_files = Glob('GTSRB/Final_Training/Images/*/*.ppm')\n",
        "np.random.seed(10)\n",
        "np.random.shuffle(all_files)\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "trn_files, val_files = train_test_split(all_files, random_state=1)\n",
        "\n",
        "trn_ds = GTSRB(trn_files, transform=trn_tfms)\n",
        "val_ds = GTSRB(val_files, transform=val_tfms)\n",
        "trn_dl = DataLoader(trn_ds, 32, shuffle=True, collate_fn=trn_ds.collate_fn)\n",
        "val_dl = DataLoader(val_ds, 32, shuffle=False, collate_fn=val_ds.collate_fn)\n",
        "\n",
        "import torchvision.models as models\n",
        "\n",
        "def convBlock(ni, no):\n",
        "    return nn.Sequential(\n",
        "        nn.Dropout(0.2),\n",
        "        nn.Conv2d(ni, no, kernel_size=3, padding=1),\n",
        "        nn.ReLU(inplace=True),\n",
        "        nn.BatchNorm2d(no),\n",
        "        nn.MaxPool2d(2),\n",
        "    )\n",
        "    \n",
        "class SignClassifier(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.model = nn.Sequential(\n",
        "            convBlock(3, 64),\n",
        "            convBlock(64, 64),\n",
        "            convBlock(64, 128),\n",
        "            convBlock(128, 64),\n",
        "            nn.Flatten(),\n",
        "            nn.Linear(256, 256),\n",
        "            nn.Dropout(0.2),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Linear(256, len(id2int))\n",
        "        )\n",
        "        self.loss_fn = nn.CrossEntropyLoss()\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.model(x)\n",
        "\n",
        "    def compute_metrics(self, preds, targets):\n",
        "        ce_loss = self.loss_fn(preds, targets)\n",
        "        acc = (torch.max(preds, 1)[1] == targets).float().mean()\n",
        "        return ce_loss, acc\n",
        "def train_batch(model, data, optimizer, criterion):\n",
        "    ims, labels = data\n",
        "    _preds = model(ims)\n",
        "    optimizer.zero_grad()\n",
        "    loss, acc = criterion(_preds, labels)\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "    return loss.item(), acc.item()\n",
        "\n",
        "@torch.no_grad()\n",
        "def validate_batch(model, data, criterion):\n",
        "    ims, labels = data\n",
        "    _preds = model(ims)\n",
        "    loss, acc = criterion(_preds, labels)\n",
        "    return loss.item(), acc.item()\n",
        "model = SignClassifier().to(device)\n",
        "criterion = model.compute_metrics\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "n_epochs = 40\n",
        "\n",
        "log = Report(n_epochs)\n",
        "for ex in range(n_epochs):\n",
        "    N = len(trn_dl)\n",
        "    for bx, data in enumerate(trn_dl):\n",
        "        loss, acc = train_batch(model, data, optimizer, criterion)\n",
        "        log.record(ex+(bx+1)/N, trn_loss=loss, trn_acc=acc, end='\\r')\n",
        "\n",
        "    N = len(val_dl)\n",
        "    for bx, data in enumerate(val_dl):\n",
        "        loss, acc = validate_batch(model, data, criterion)\n",
        "        log.record(ex+(bx+1)/N, val_loss=loss, val_acc=acc, end='\\r')\n",
        "        \n",
        "    log.report_avgs(ex+1)\n",
        "    if ex == 10: optimizer = optim.Adam(model.parameters(), lr=1e-4)\n",
        "\n",
        "log.plot_epochs()\n",
        "dumpdill(log, '40-yes-aug-yes-bn.log')\n",
        "from google.colab import files\n",
        "files.download('40-yes-aug-yes-bn.log')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020-09-17 09:54:30.795 | INFO     | torch_snippets.loader:Glob:172 - 39209 files found at GTSRB/Final_Training/Images/*/*.ppm\n",
            "2020-09-17 09:54:30.808 | INFO     | __main__:__init__:46 - 29406\n",
            "2020-09-17 09:54:30.809 | INFO     | __main__:__init__:46 - 9803\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 1.000\ttrn_loss: 1.840\ttrn_acc: 0.462\tval_loss: 0.752\tval_acc: 0.762\t(62.07s - 2420.80s remaining)\n",
            "EPOCH: 2.000\ttrn_loss: 0.679\ttrn_acc: 0.780\tval_loss: 0.432\tval_acc: 0.858\t(125.57s - 2385.74s remaining)\n",
            "EPOCH: 3.000\ttrn_loss: 0.480\ttrn_acc: 0.845\tval_loss: 0.369\tval_acc: 0.878\t(189.63s - 2338.78s remaining)\n",
            "EPOCH: 4.000\ttrn_loss: 0.397\ttrn_acc: 0.871\tval_loss: 0.299\tval_acc: 0.902\t(253.21s - 2278.87s remaining)\n",
            "EPOCH: 5.000\ttrn_loss: 0.341\ttrn_acc: 0.889\tval_loss: 0.267\tval_acc: 0.911\t(316.45s - 2215.16s remaining)\n",
            "EPOCH: 6.000\ttrn_loss: 0.297\ttrn_acc: 0.905\tval_loss: 0.246\tval_acc: 0.920\t(379.64s - 2151.27s remaining)\n",
            "EPOCH: 7.000\ttrn_loss: 0.269\ttrn_acc: 0.910\tval_loss: 0.218\tval_acc: 0.930\t(442.87s - 2087.82s remaining)\n",
            "EPOCH: 8.000\ttrn_loss: 0.250\ttrn_acc: 0.918\tval_loss: 0.198\tval_acc: 0.934\t(506.33s - 2025.32s remaining)\n",
            "EPOCH: 9.000\ttrn_loss: 0.230\ttrn_acc: 0.923\tval_loss: 0.198\tval_acc: 0.938\t(569.49s - 1961.58s remaining)\n",
            "EPOCH: 10.000\ttrn_loss: 0.211\ttrn_acc: 0.930\tval_loss: 0.173\tval_acc: 0.943\t(632.87s - 1898.60s remaining)\n",
            "EPOCH: 11.000\ttrn_loss: 0.202\ttrn_acc: 0.933\tval_loss: 0.186\tval_acc: 0.943\t(696.65s - 1836.64s remaining)\n",
            "EPOCH: 12.000\ttrn_loss: 0.145\ttrn_acc: 0.952\tval_loss: 0.130\tval_acc: 0.958\t(759.59s - 1772.37s remaining)\n",
            "EPOCH: 13.000\ttrn_loss: 0.130\ttrn_acc: 0.956\tval_loss: 0.116\tval_acc: 0.963\t(822.65s - 1708.59s remaining)\n",
            "EPOCH: 14.000\ttrn_loss: 0.119\ttrn_acc: 0.959\tval_loss: 0.113\tval_acc: 0.962\t(885.85s - 1645.14s remaining)\n",
            "EPOCH: 15.000\ttrn_loss: 0.113\ttrn_acc: 0.963\tval_loss: 0.115\tval_acc: 0.965\t(948.54s - 1580.91s remaining)\n",
            "EPOCH: 16.000\ttrn_loss: 0.109\ttrn_acc: 0.963\tval_loss: 0.106\tval_acc: 0.964\t(1011.32s - 1516.98s remaining)\n",
            "EPOCH: 17.000\ttrn_loss: 0.104\ttrn_acc: 0.964\tval_loss: 0.105\tval_acc: 0.966\t(1074.53s - 1453.78s remaining)\n",
            "EPOCH: 18.000\ttrn_loss: 0.097\ttrn_acc: 0.967\tval_loss: 0.098\tval_acc: 0.968\t(1138.27s - 1391.22s remaining)\n",
            "EPOCH: 19.000\ttrn_loss: 0.100\ttrn_acc: 0.967\tval_loss: 0.106\tval_acc: 0.966\t(1201.71s - 1328.20s remaining)\n",
            "EPOCH: 20.000\ttrn_loss: 0.098\ttrn_acc: 0.966\tval_loss: 0.095\tval_acc: 0.969\t(1265.57s - 1265.57s remaining)\n",
            "EPOCH: 21.000\ttrn_loss: 0.095\ttrn_acc: 0.968\tval_loss: 0.098\tval_acc: 0.969\t(1329.09s - 1202.51s remaining)\n",
            "EPOCH: 22.000\ttrn_loss: 0.094\ttrn_acc: 0.967\tval_loss: 0.093\tval_acc: 0.972\t(1393.45s - 1140.09s remaining)\n",
            "EPOCH: 23.000\ttrn_loss: 0.090\ttrn_acc: 0.970\tval_loss: 0.096\tval_acc: 0.971\t(1457.31s - 1077.14s remaining)\n",
            "EPOCH: 24.000\ttrn_loss: 0.085\ttrn_acc: 0.971\tval_loss: 0.092\tval_acc: 0.972\t(1521.21s - 1014.14s remaining)\n",
            "EPOCH: 25.000\ttrn_loss: 0.089\ttrn_acc: 0.970\tval_loss: 0.096\tval_acc: 0.968\t(1585.12s - 951.07s remaining)\n",
            "EPOCH: 26.000\ttrn_loss: 0.085\ttrn_acc: 0.971\tval_loss: 0.090\tval_acc: 0.972\t(1649.27s - 888.07s remaining)\n",
            "EPOCH: 27.000\ttrn_loss: 0.080\ttrn_acc: 0.972\tval_loss: 0.083\tval_acc: 0.974\t(1713.44s - 824.99s remaining)\n",
            "EPOCH: 28.000\ttrn_loss: 0.080\ttrn_acc: 0.973\tval_loss: 0.095\tval_acc: 0.972\t(1777.52s - 761.79s remaining)\n",
            "EPOCH: 29.000\ttrn_loss: 0.080\ttrn_acc: 0.972\tval_loss: 0.081\tval_acc: 0.975\t(1841.47s - 698.49s remaining)\n",
            "EPOCH: 30.000\ttrn_loss: 0.081\ttrn_acc: 0.972\tval_loss: 0.088\tval_acc: 0.974\t(1905.06s - 635.02s remaining)\n",
            "EPOCH: 31.000\ttrn_loss: 0.075\ttrn_acc: 0.975\tval_loss: 0.084\tval_acc: 0.972\t(1968.86s - 571.60s remaining)\n",
            "EPOCH: 32.000\ttrn_loss: 0.081\ttrn_acc: 0.973\tval_loss: 0.089\tval_acc: 0.972\t(2032.45s - 508.11s remaining)\n",
            "EPOCH: 33.000\ttrn_loss: 0.076\ttrn_acc: 0.974\tval_loss: 0.089\tval_acc: 0.971\t(2095.91s - 444.59s remaining)\n",
            "EPOCH: 34.000\ttrn_loss: 0.072\ttrn_acc: 0.975\tval_loss: 0.083\tval_acc: 0.975\t(2159.69s - 381.12s remaining)\n",
            "EPOCH: 35.000\ttrn_loss: 0.072\ttrn_acc: 0.975\tval_loss: 0.087\tval_acc: 0.974\t(2223.42s - 317.63s remaining)\n",
            "EPOCH: 36.000\ttrn_loss: 0.070\ttrn_acc: 0.976\tval_loss: 0.079\tval_acc: 0.977\t(2287.19s - 254.13s remaining)\n",
            "EPOCH: 37.000\ttrn_loss: 0.071\ttrn_acc: 0.975\tval_loss: 0.081\tval_acc: 0.975\t(2351.40s - 190.65s remaining)\n",
            "EPOCH: 38.000\ttrn_loss: 0.071\ttrn_acc: 0.976\tval_loss: 0.074\tval_acc: 0.975\t(2415.64s - 127.14s remaining)\n",
            "EPOCH: 38.106\ttrn_loss: 0.100\ttrn_acc: 0.938\t(2421.79s - 120.40s remaining)"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NoJtmoBZ3y12",
        "outputId": "e67404e4-033f-45ce-e44c-f66ef2afd8e1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "for f in Glob('*.log'):\n",
        "    log = loaddill(f)\n",
        "    print()\n",
        "    log.report_avgs(20)\n",
        "    log.plot_epochs(['trn_acc', 'val_acc'], title=f.replace(',','\\n').replace('.log',''))\n",
        "    print()\n",
        "    line()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020-09-17 09:35:05.018 | INFO     | torch_snippets.loader:Glob:172 - 4 files found at *.log\n",
            "  0%|          | 0/20 [00:00<?, ?it/s]/usr/local/lib/python3.6/dist-packages/numpy/core/fromnumeric.py:3335: RuntimeWarning: Mean of empty slice.\n",
            "  out=out, **kwargs)\n",
            "/usr/local/lib/python3.6/dist-packages/numpy/core/_methods.py:161: RuntimeWarning: invalid value encountered in double_scalars\n",
            "  ret = ret.dtype.type(ret / rcount)\n",
            "100%|██████████| 20/20 [00:00<00:00, 351.47it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\rEPOCH: 20.000\ttrn_loss: 0.031\ttrn_acc: 0.990\tval_loss: 0.077\tval_acc: 0.978\t(8455.42s - 0.00s remaining)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 20/20 [00:00<00:00, 358.36it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "==================================================================\n",
            "\n",
            "\rEPOCH: 20.000\ttrn_loss: 0.391\ttrn_acc: 0.869\tval_loss: 0.323\tval_acc: 0.889\t(9196.88s - 0.00s remaining)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfEAAAGeCAYAAACEkDjyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXhU1f3H8ffJvieQhLAE2ZF9jeBWCSruiFQpKlq1VbRqrba1pb+21lpbu7e2Wq217iLuintVCO7IKlsA2YSEJQmBrGSbOb8/7gRCTCAkczOZyef1PNM7c++dc78n9eE759xzzzHWWkRERCT4hAU6ABEREWkdJXEREZEgpSQuIiISpJTERUREgpSSuIiISJBSEhcREQlSSuIiIiJBSklcREQkSCmJi4iIBCklcRERkSClJC7SARljrjbGvGiM2WKMOWCMKTXGfGyMuaKJc7cZY7Y1U86dxhhrjMlu4tgsY8xyX/kFxpgnjTE9jTE5xpgWzcdsjLneV/6vmjne3RhTa4xZ3Wh/hDHmRmPMZ766VRpjVhhjbjbGfO3fJWPMhcaY940xu4wx1caYncaYRcaYG1sSp0ioUhIX6ZgeAPoAHwB/B+b5Pj9pjPlNWws3xvwEeAroCzwOPAoMBz4GUo6hqKeBUuC7xpjwJo5/B4gA/t3g2pHA68D9vmvNBR7C+ffon754GsY6G3gVGAa8BvwFeBOIBa45hlhFQk5EoAMQkSaNsNZubrjDGBMFvAXMMcY8aK3Nb03Bxpj+wG+BImCctXaHb/8cnIR6aUvLstaWG2OeBG4CzsVJzvXXMcC1QCXwZIOv/Rw4G7gPuNVa6/GdH46TzL9jjHnBWvuq7/zrgRpgtLW2oFFd0loaq0goUktcpANqnMB9+2pwWq8RwBltKP5yXxn/rE/gvvItMAfwHGN5D/i21zfafxbQD3jWWlsC4Osq/z6wG7itPoH7ru8BfgRYYFajsuqA2sYXttYWHWOsIiFFLXGRDsgYcxzwU5xkfRxO13FDvdpQ/Fjf9qPGB6y1XxljduB0s9fHkgLc2kQ5f7fW7rfWrjXGfACca4zp3eCHwWzf9sEG3xkMdAW+BH7hNNa/5gAwtMHnp3G60NcZY+YBi4CPrbWFR66mSOhTEhfpYHzd3Z8DXYAPgf8BJTgt5L7AVUB0Gy6R7Nvuaeb4HhokcZz71k0NXHsM2O97/y/gNJzu818ZY7oDFwIrrbWfN/hOqm87qJky6yXUv7HW/tUYUwTcCNyC84PCGmMWAbdba5ceoRyRkKYkLtLx/BAn2V1jrX2s4QFjzGU4SbwhLxDVTFlNDVIr9W0zgLVNHM9o+MFauw1ossncwEs4yf+7xpi7aGJAm0+Jb/uytfabRymzYQxPAE/4egVOBqb7rvGOMWaIWuXSWemeuEjHM9C3fbGJY5Oa2LcPyPCN+m4sq4l9K3zbUxsfMMb0AXq3JMiGrLW1wMM43fxTcVrk5Thd4Q2tx2m9n9hMvEe7zn5r7ZvW2utwegK64vQAiHRKSuIiHc823za74U5jzNk4ybGxz3Favdc0Ov9q4JQmzp+LM1Ds+8aY3g3ON8A9QFOPirXEQzhd/vfhDGiba60ta3iCtbYO5zGyHsA/jDGN7/VjjOlhjBnW4PNk0/TN826+bWUr4xUJesYZkCoiHYUxZhSwBGeU9gvATmAEcA7wHDAT+LW19k7f+cOA5UCk7/wdwBjgJGABcAEw2Vqb0+AaPwN+h9OKfxanm3sKTsu2BBhlrT3mH/nGmFdx7oUDjLfWLm/inPo4LwTyfTHm4yTlQTg/PH5urf297/z9OK36z3B+4BjgG8AJwDLgJF9PgEino5a4SAdjrV0FTAY+Ac4HvgckAd/k8JHe9eevA87EmahlKs6o8GqcJL6smWvcA3wb+AqnBf9dIBcngUZw6L75sXrEt13aVAL3XbsWuMh3/Q04PzJ+hPMjJQz4JYd3w8/B+VEzDmdw2zU4P1h+ivPjRAlcOi21xEXkIGNMEs4AtZXW2pNa8f07cUadX2ut/a+fwxORRtQSF+mEjDHpjQeWGWMicJ7HjgFebkWZicANQDHwjD/iFJEj0yNmIp3TxcBdxpj3cO6h14/yHgysxBl81iLGmPNxurqn4jye9mNrrQabibQDJXGRzmkxzoxtp3FoApatOHOq/8Fae+AYypqB8+z6HpzR7X/zY5wicgS6Jy4iIhKkdE9cREQkSCmJi4iIBCklcZEgZozpa4yxxpjHAh2LiLQ/JXEREZEgpSQuIiISpJTERUREgpSSuEiIMMYMMca8YowpNsZUGGM+Msac1eicq3330K/2rQ6WY4wpM8aUGmPeMMYMPcZrtqo830pl9xtjthljaowxhcaYl4wx49vyNxDpbJTERUJDP+BTnJnX/g08D4wH3jLGzGzi/AuA/+EsdPIg8CFwHrDIGJPWiuu3uDxjTD9gKc5iJptxpnp9B2exl0+MMRe04voinZKSuEhoOA142Fp7mrX2Z9baq3GW6/QCD/oWNmnoIuAca+2F1trbrbXnA78H0oHvtOL6x1Leg0BP4BfW2jN88V6Bs3JbOPC4MSahFTGIdDpK4iKhoQS4q+EOa+1SnCU9U4Dpjc6fZ619v9G+h3zbCa24fovKM8ZkAmcB24E/Nor3E5yFU7riLLsqIkehudNFQsNya21ZE/tzcOY1Hws83mD/0ibO3eHbdqnfYYzJBrIbnbfNWvtYo30tKs8XB8CHzawDvgC4wnfeE00cF5EGlMRFQsOeZvbv9m2TG+3f3/hEa22dMQacLu162Tjrgze0CHisleXVx7GrmXjr96c0c1xEGlB3ukhoyGhmf3fftqQ1hVpr77TWmkav7FZFeHgc3Zs53qPReSJyBEriIqFhnDEmsYn92b7tinaM5Ujq4zjVGNNUT+Bk33Z5O8UjEtSUxEVCQzJwR8MdxpgsYBZOq/blQATVmLU2D3gX6Avc2vCYMWYicDmwjw4Sr0hHp3viIqHhA+BaXyL8GKdbeibOD/XrrbWlgQyukRtwYvyTbzKapUBvYAbOI3HXNDNIT0QaUUtcJDRsBU7GacXeAHwLp0v6PGvts4EMrDFr7RYgC+d58eOBHwPnAm8Dp1hrXw1geCJBxVhrAx2DiIiItIJa4iIiIkFKSVxERCRIKYmLiIgEKSVxERGRIKUkLiIiEqSC7jnxtLQ027dv30CH4XcVFRXEx8cHOgxXhXodVb/gF+p1VP2C07Jly4qstelNHQu6JN63b1+WLm1qwaTglpOTQ3Z2dqDDcFWo11H1C36hXkfVLzgZY75q7pi600VERIKUkriIiEiQUhIXEREJUkF3T7wptbW15OXlUVVVFehQWi05OZnc3FxXyo6JiSEzM5PIyEhXyhcRkcAIiSSel5dHYmIiffv2xRgT6HBapaysjMTEppaDbhtrLXv37iUvL49+/fr5vXwREQmckOhOr6qqIjU1NWgTuJuMMaSmpgZ1L4WIiDTN1SRujDnHGLPBGLPJGDOnieN9jDHvG2NWGWNyjDGZbbhW24INYfrbiIiEJteSuDEmHLgfZ53gYcBlxphhjU77M/CEtXYUcBdwj1vxuGn//v3861//CnQYIiLSybjZEp8AbLLWbrHW1gDzgGmNzhkGLPC9X9jE8aDQXBKvq6sLQDQiItJZGGutOwUbcwlwjrX2Wt/nK4GJ1tqbG5wzF1hsrb3XGPNN4EUgzVq7t1FZs4HZABkZGePnzZt32LWSk5MZOHCgK/Voiauvvpo333yTQYMGERERQUxMDCkpKWzcuJF//OMf3HPPPaSmprJu3TrGjBnDww8//LUubo/HQ3h4OL///e956623qKqqYuLEidx7770YY9i8eTO33XYbRUVFhIeH8/jjj9O/f3/+9re/8eyzzxIWFsaUKVP49a9/3WSMmzZtoqSkpD3+HM0qLy8nISEhoDG4SfULfqFeR9UvOE2ePHmZtTarqWOBHp3+Y+A+Y8zVwAdAPuBpfJK19iHgIYCsrCzbeFq93NzcgyO7f/3aWtbtLPVrkMN6JvGrqcObPf6Xv/yFDRs2sGrVKnJycjj//PNZs2YN/fr1Iycnh1WrVrF27Vp69uzJKaecwqpVqzj11FMPK6N+dPqPfvQjfvvb3wJw5ZVXsmjRIqZOncr111/PnDlzmD59OlVVVXi9XhYtWsTbb7/NkiVLiIuLo7i4uNkR7jExMYwdO9Z/f5RWCNUpEeupfsEv1Ouo+oUeN5N4PtC7wedM376DrLU7gW8CGGMSgIuttftdjKldTJgw4bDHuSZMmEBmpjNmb8yYMWzbtu1rSbzewoUL+eMf/0hlZSXFxcUMHz6c7Oxs8vPzmT59OuAkZID33nuPa665hri4OAC6du3qZrVERDona8FbB3XV4KlxXhHRENsFvF7YverQfk8NZJ4A0f5/ZLgpbibxJcAgY0w/nOR9KXB5wxOMMWlAsbXWC/wMeKStFz1Si7m9NF5FJzo6+uD78PDwZu+VV1VVceONN7J06VJ69+7NnXfeqUfDRKRz8NTBgWKoKILKIrBe6J/tHFs5F/bvAOsBr8fZJvWCCdc5xz/8K5TkMTg/D0pecJJu2iA49Vbn+Bs/hvLdTsKtL6P3BJj0E+f441OhYi946pN0LQydCuf9yTl+d4ZzrKETroPz/+wk94cmHX7sho+g+0g3/kpf41oSt9bWGWNuBt4BwoFHrLVrjTF3AUuttfOBbOAeY4zF6U6/ya143JSYmEhZWVmby6lP2GlpaZSXl/PCCy9wySWXkJiYSGZmJq+88goXXXQR1dXVeDwepkyZwl133cWsWbMOdqerNS7SSVkLNRVQtR8O7HNe3UdBbArsXAlrX2bAV9vAfgKRcRAVD8OnQ3walOTDvq3O/sg4iIqDyHjnu2HhrYvHUwfhvhSzezUUbjiUoCuKnP1T/+5sn/s2rJsPNBij1XUA3LLceb/8Cdj+qfPehIEJh8ysQ0l803tQuJ60Wg+Uxzrn1DVoABVvhtJdTl1MmLOtajBGKKE7RCdBeJTzioiCHqMPHT/tdjD4jkdDeCRk+BqM4ZFw6dxD+yOioUv7Tazl6j1xa+2bwJuN9t3R4P0LwAtuxtAeUlNTOeWUUxgxYgSxsbFkZGS0qpyUlBSuu+46RowYQffu3TnhhBMOHnvyySe5/vrrueOOO4iMjOT555/nnHPOYeXKlWRlZREVFcV5553H7373O39VS0QCwetxEsyBfRDX1emyLd0F618/lJzrX6fd7iSzje/AvFngrT28rKvfgL6nwt5N8On99CQM8l45dLzPyU4SX/86vPWTr8dyy0ro2g8+vR8++tuh5F+f6Gc+BTHJsO5VWPUcVBQeStS1B+AXBWAMLH4QVjzllGnCILYrpDS42zrobEgf6sQSl+psExr8O3rVa77kHeaU19g1Tpr5pLl74le+fOS/+cX/OfLxSbc3f8wYGHL+kb/vokAPbAsZc+fObXJ/dnb2Yf9R3XfffUcs5+677+buu+/+2v5BgwaxYMGCr+2fM2cOc+Z8bR4dEelI6mqc+6aVe51XRZGzHTTFSbJFm+CZmc6+A/s52CKddj+MvQJK8uDNHzv7ohKdxB6bAjXlzr6u/eHkm539MSm+410gY4RzfPg3YcTFfLhoEdmnnQZ1B6Cm0ikDYOiF0G2os6+2wrethPh053jaYCdR1e+vqXC2Yb4UUrgBirdCfKrTgo1Pg7g0p6s5PNL5sXHS9539sV2+3rofO+vIf79wrfvQHCVxEZFjUVcNxVugbJeTqHqMcpL023MOJenKYmd7wned+65VJfDwGYeXExYJCd2cJB6T5NxDjUt1Wqn1LfDeE5xze4yGH29ykm5TCS1tEJx5Z/Mxh4Ud/j4q3nnVS+rhvJozaIrzas6knxy6v9yULn2bPyZtoiQeINOnT2fr1q0HP3u9Xv70pz9x9tlnBzAqEQGc+8vlBU5LN3WA8/nZK2DPWtj/lTPoCpxW8rT7ncS6/nWnazku1emCzhx/6L5pXFe4/HnnWFxXp0UalXCoazihG8x4rPl4IqIgId3VKktwUhIPkJdfPvwejVurmInIEXg9h7p2lzzMkNzX4Mu7nO7t6hLoNwmumn8o2fYcAyNnOC3f5N6H7usaAz/e2Px1wsJh8Fnu1kU6JSVxEekcdn0B+cucBF20EfZ+6Ywovvlz53ju66TsXw09R8CoGZA66PDHhC59OjBxixyBkriIhJ7qMlj+JKx/A65+3TdC+iFY+RRExELaQOg5Dro1WJNp1gt89uFHnW7GL2m9qloPBaXV7CmrYk9pFXtKqykoraLG4223OUuUxEUkdJTuhMX/hqWPOt3hvbKchB6TBNk/hew5ziQhYU2s/RSufw4DxVrLgVoPpQfqKDlQS8mBWkp9W4/XEhcdTnxUBHFR4cRHRzivqHDioiOIiwwnLMy/yy1X1znJuaDMScx7SqsoKPNtfZ/3lFZRWvX1ibuiIsLo3SUWa227LAOt/2pFJDTkL4f/nuXMyDVsmvNIU+b4Q8dTjgtcbJ2Ax2spr2qQhKsOT8aH9tUd3F/a4LxaT+sX44qLCicuKoIwbw2pX3xI/MFk7+yvT/gH90dFEB0ZRsmB2oMt6IMJuqyK/ZW1X7tGZLihW2IM3ZKiGZCewMkDUumWFEO3xGgykmJ8r2iSYyPbJXnXUxIXkeBkLWzJcR7lGnmJ8xjWqbfBmMud0eHSJtZaKmo8FJVVU1ReTVF5jW9bzd4m3pdV13GkRTHDwwzJsZEkxUQ429hIenWJ9e2LJDk20rc/4tD7mEgiwg2VNR4qqusO25ZX11FZU0dFtcfZ1njYuj2f+JRYKmvq2H+glp37DzjfqamjorquyR8KEWGG9MRouiXF0Cc1jgn9upKRFH0wYdcn6JTYSL+3+P1BSTwAEhISKC8vD3QYIsHJUwtrXoJP/gl7VkO34TDiYmcE+Ok/D3R0HZrXWoorathbXk2hLzHv9SXjorIa9lZUU1heQ1FZNXsrqqmq9TZZTkpcJGkJ0aTGRzG0ZxJp8VEkx0UdlqTrE3X9Nj4q3PUWak7OXrKzm1yxE4CaOu/BhH+gpo6UuCi6xkV1yOTcUkriIhI81r8Bb94OpfmQdjxceB+M+lbTU3F2QAdqPBSWVVNYXuVsy6op8G2d/U7L1utr0loLlobvOfieJvfbw86x9eX4/qeypg7PO+9+La7wMENqfBSpCdGkJUQxIC2e1IQo0hKinWTte5+eGE2XuCiiIpoYUxAEoiLCiIqIIiUu0JH4T2gm8UebmMd2+EXOZPk1lfD0jK8fH3O5M/VfxV5nMv6GrnnjiJebM2cOvXv35qabnPVb7rzzTiIiIli4cCH79u2jtraWu+++m2nTph019PLycqZNm9bk95544gn+/Oc/Y4xh1KhRPPnkk+zZs4cbbriBLVu2APDAAw9w8sknH/U6IkGjJM+Z3jOxuzOlaNf+cMHfYeCZTQ9Qa2cer3VasM0k5cKyaop8+8urvz4QKsxAakI06b4kOTA9gfAwc/B3icF5Y0zD3yoNj3PYuYfvP/Tjxhgo3JXPuGGDSEt0knV9ku6oXcVydKGZxNvZzJkzufXWWw8m8eeee4533nmHW265haSkJIqKijjxxBO58MILj9qdFBMTw8svv/y1761bt467776bTz75hLS0NIqLiwG45ZZbmDRpEi+//DIej0fd9BI6dq2CT++DNS/C+GucZR/7nuI8MhYABaVVrNlZwpr8Utbkl7Bj3wEKy6oprqjG28S94MToCNITncQ8rGcSk3zv65N1t8QY0hOj6RofRXg7JdCcnEKyT9V4gVASmkn8SC3nqLgjH49PPWrLu7GxY8dSUFDAzp07KSwspEuXLnTv3p3bbruNDz74gLCwMPLz89mzZw/du3c/YlnWWv7v//7va99bsGABM2bMIC0tDeDgkqMLFizgiSeeAJy1ypOTk48pdpEOZ/NC+PjvzqC1yHiYMBtO/F67Xd5ay86SKtbklxx67SylsMxZT9oY6J8WT9/UeMb0TnaSclJMg+TstG5jo1q5hKfIMQjNJB4AM2bM4IUXXmD37t3MnDmTp59+msLCQpYtW0ZkZCR9+/Y9uF74kbT2eyJBzVN7aGGPNS9CwXpnQY/xVzsLgbjEWstXeysPtrA/XHOA2z54l32+R4zCwwyDuiVw2qB0RvRKYkSvZIb2SCIhWv90Sseg/xL9ZObMmVx33XUUFRWxaNEinnvuObp160ZkZCQLFy7kq6++alE5JSUlTX7v9NNPZ/r06fzwhz8kNTWV4uJiunbtyhlnnMEDDzzArbfeerA7Xa1xCQrWwp41sOEtWPoIzHzaea57yl1w/l+dRT/8yOO1bC0qP9gdvmZnCWt3llLmm7AjMtzQM95w9vDujOiVzIheyQzpnkhMpFrU0nEpifvJ8OHDKSsro1evXvTo0YNZs2YxdepURo4cSVZWFkOGDGlROc19b/jw4fz85z9n0qRJhIeHM3bsWB577DHuvfdeZs+ezX//+1/Cw8N54IEHOOmkk9ysqkjbVBbDu3fApvec5TzBWWikfpBaXFe/XKaiuo631uxmdd5+1uwsZd3OUg7UegCIiQxjaI8kLhrTixG9khjeM5nBGYl88tEHZGeP8sv1RdqDkrgfrV69+uD7tLQ0Pv300ybPO9LgsyN976qrruKqq646bF9GRgavvvpqK6IVaQfWQuF6+PJ/EJ0EWddAdKJz37v3BBh0ljPKPPHIY0WO1aKNhfzfS6vJ33+A+KhwhvdM5tIJvRnRM5mRmcn0T4snIjzwI9tF2kpJXET8b/MCyH0NvnwXSnY4+4Ze6CTx8Ei4bY0rz3bvq6jhN6+v46UV+QxIj2fe7BOZ0LerHp+SkKUkHiCrV6/myiuvPPjZ6/USGxvL4sWLAxiVSCtYC3s3w/ZPYJxvjoXlT8DG/8GAyXDaj2HgFEjudeg7fk7g1lpeW7WLX89fS8mBWm45fSA3nT6Q6Ajdz5bQFjJJvL1WjPGXkSNHsnLlyoOfy8rKSExMdOVa9kgTGou0Ru0B2PaR003+5f9g3zZnf/9sZ6GRc/8I0/8NEdGuh7Kr5AC/eHkN768vYHRmMk9fN5Eh3ZNcv65IRxASSTwmJoa9e/eSmpoaVIm8PVhr2bt3LzExMYEORYKZtcQc2OXMaBif6nSVv3SdszZ3/0lw0s0waMqhlcISurkektdrefrz7fzhrfXUeb384vyhXHNKv3abOEWkIwiJJJ6ZmUleXh6FhYWBDqXVqqqqXEu0MTExZGZmulK2hACvB8oLnLW447o405pWFsNbP3VGj5fuhNKdnFh3AFLugZNudBL2FS9Cn1Mhsv1/IG4uLOdnL67m823FnDowjd9NH8lxqSE0IbZIC4VEEo+MjKRfv+CeSjAnJ4exY8cGOgwJNbVVULbTl4h3QWIG9DvNmVzlkXOcJF2221mDG5wW9dm/dbrBt38GST2hxyg4/lw2FtUweOgFznmxXZxR5e1dHY+Xhz7Ywr3vf0lMRBh/vGQUM8ZnqgdOOq2QSOIigjPXeOF6Z1UvgH+Mg+LNh58z/JtOEg+PhIQMSBvsJOqkHpDUC9J98xlExcNtqw/76s6cHAbXd5cHwKq8/fz0xdXk7irlvJHdufPC4XRL1G0i6dyUxEWCWU2FM03psscgfxkcd9KhJD76Mmcpq6RekOhL0kk9D333srmBiPiYHajx8Lf3NvLwh1tIS4jm31eO5+zh/n2uXCRYKYmLBKuljzozn1WXOi3oc/4Ao2ceOj7p9sDF5iefbCriZy+v5qu9lVw2oTdzzh1KcmxkoMMS6TCUxEWCRU0lrH3Z6Q5P6Q3JmXD8uc4ynced6MrkKYFScqCW372Ry7NLd9A3NY65103k5AFpgQ5LpMNREhfp6ApynVb3qnlQVQJTfgOn3OKMEB80JdDR+d3ba3bxy1fXUlxRw/WT+nPbmYO1CIlIM5TERToqrweevAi2fgDhUYemLe1zSqAjc0VBWRW/enUtb63ZzbAeSTx69QmM6KUV+USORElcpCMp3OjMO37iDRAWDj1GO1OWjrkc4kOzO9lay/NL87j7jXVU1Xm5/ezjmX1afyK1QInIUSmJiwRaXTWsmw/LHoWvPoawSBh+kbOy11l3Bzo6v/N6LVv3VrAmv4RVeSV8vrWY1fklTOjblXsuHsmA9IRAhygSNJTERQLpq09h3uVwoBi69IUz74QxV0BCeoAD8w+v17JtbwWr80sOJu21O0spr64DIDrCWdf7t9NHcNkJx2m1MZFjpCQucjRle6C2Erx14KlxZjuLjIP0wc7xrR9CdRnpBStgdZFzPKmHsxgIwOKHnMfADn6/BvqeBoPPgm5DnPPGXQn9siEseLuQrbV8tbeSVQcT9n7W5pdS5kvYUb6EPX1sL0b2SmZEr2QGZSSo21ykDVxN4saYc4B7gXDgYWvt7xsdPw54HEjxnTPHWvummzGJHFXZbqdbe8TFzuenvgl71hx+Tr/T4KrXnPfzb4Z92xgOsM53/PjzDiXxRX+AyiLnvQl3Zkvbv91J4rFdYMajrlbHDdZathdXsjq/hNV5Jc42v4SyKl/CDg9jaI9Epo3teTBhD85IVMIW8TPXkrgxJhy4H5gC5AFLjDHzrbXrGpz2C+A5a+0DxphhwJtAX7diEjmiymL4+O9Oyxmg/2SI6wrZP4PqMif5hkc696wbrtL1rSfBeliy/AtOmHiyc050g2Vlf/DFoe8FYUu7us7D9r2VfL67jk/fymWNL3GXNkjYQ3okMnV0T0Y1SNhREcFXV5Fg42ZLfAKwyVq7BcAYMw+YxqG2CoAF6hf+TQZ2uhiPSNOqy+DTf8Gn9znvR86A7DlOAgeoX/SjOT1GAVCxseRQF3tD0R1/oJa1loKyajYXlrOlsMJ5FZWztaiCHcWVeH1L0keGb2VI9yTOH9WTUZnJjFTCFgkoY611p2BjLgHOsdZe6/t8JTDRWntzg3N6AP8DugDxwJnW2mVNlDUbmA2QkZExft68ea7EHEjl5eUkJHT8f+zboqPWMebAbiZ8fhN7U7PY1vdyKhL6tKqcjlq/hqrqLLsrvOyu9G0rvOyqsOyp8FLlOXReVHqHbxYAACAASURBVDh0jwuje7yhe3wY3ePD6BJWxcBu8USG8OCzYPj/sC1Uv+A0efLkZdbarKaOBXpg22XAY9bavxhjTgKeNMaMsNZ6G55krX0IeAggKyvLZmdnt3+kLsvJySEU69VQh6ljXQ2seAJ2roBp9zv7Tj6V9ORM2jImvKPUz+O15O87wOYip1W9tehQ63p3adXB84yBXimx9O+ewOS0ePqnx9M/LYH+6fF0T4r52kjxjlI/N4V6HVW/0ONmEs8Hejf4nOnb19B3gXMArLWfGmNigDSgwMW4pLPyemDVc5BzD+z/Cnqf6KwCFhXvzEMehOo8XjbuKWfljv18sWM/X+TtZ0tRBTV1h34HJ8VE0D89gZMHpjIgPYF+voTdNzVe05mKBDk3k/gSYJAxph9O8r4UuLzROduBM4DHjDFDgRig0MWYpLPasw6evxqKNjizoJ3/Fxh4ZlAtGmKtZWdJFSu3O8l65fb9rM4v4UCt0w+eEhfJ6MwUJg1Op396PP18rerU+ChMENVTRFrOtSRura0zxtwMvIPz+Ngj1tq1xpi7gKXW2vnAj4D/GGNuwxnkdrV16ya9dD7WOiPO41OddbRju8C3nnDmIA+CpFZyoJbVeSWs3LGPlTtKWLljP0Xl1YDzzPXwnknMPKE3Y49LYXRmCn1S45SsRToZV++J+575frPRvjsavF8HhOZqDhJY2z6C93/jjDa/4SOITYHvvhPoqJpVU+dlw+6yBgl7H5sLKw4e758ez2mD0xjTO4UxvVMY0j1JI8JFJOAD20T8K3+Zk7y3LITEHnDaj8F6gY6T8OonSlm5Y//Be9lrdpYevI+dlhDFmN4pTB/bi9G9UxiVmUJybGSAoxaRjkhJXELHpved2dViuzoLh5xwLUTGBjqqg/aUVvHi8jxeWJbHFl8rOyYyjFG9UrjqpD6M6d2F0b2T6ZUSq25xEWkRJXFpXwW5zrSmWOeeNdZZK7vfac7xnSugvODQMWudRDxgsnP8q0+hovDQMeuBmBQYeIZTxtm/g7FXQkxS09dvZ9V1Ht5bV8Dzy3bwwcZCvBYm9O3KNSf3ZXyfrgzOSCBCU5GKSCspiYu7dq6Azx6AC+9zPn/0N1j17OHnxKXBTzY77xf9CTa8cfjxLn2dqUsBcn4HWz84/HhKH7hlpTO16Uk3+b0Kx8pay5r8Up5ftoNXV+6k5EAtPZJjuDF7IJeMz6RvWnygQxSREKEkLu4oL4D374IVT0FcKhRtdPZ/48cw/mrA+EaIGwhv8J/hlLvgGz8Cw6FzwqMPHZ96r/Nsd8PvJ3bvEHOSl1ZbHv5wCy8sy2P97jKiIsI4e3h3ZozP5JSBaYSH8ExnIhIYSuLiX546WPwALPqjs3znSTfBpJ9ATDKsz/HNLd7E/OL10gYeufyu/f0ZbZvVerwsXF/A88vyWJBbicfmMrp3CndfNIKpo3tqQJqIuEpJXPzLhMHqF+C4k+Ds30LaoEBH5IoNu8t4fukOXlmZT1F5DWkJ0UzpE8kPp5/E4IzEoxcgIuIHSuLSdoUbnXvV5/3FmVjlqvlOyzvE7K+sYf4XO3l+aR6r80uIDDecMSSDS8ZnMun4dD7+8AMlcBFpV0ri0noH9sOiP8DnD0FkHOxZDf2zQyqBe7yWD78s5Plleby7dg81Hi9DeyRxxwXDmDamJ6kJ0UcvRETEJUricuyshWWPwoK7nWlNx30bTv8lJLRlDbCOw+O1rNyxj3fXFfDKinx2l1aREhfJ5ROP45LxmYzoFTo/UkQkuCmJy7EzBjYvgLTj4dzfOwuKBLm95dUs2ljIwg2FfPhlIfsrawkPM0wanM4dU4dxxtBuREdoxS8R6ViUxKVl9m+H9+6ESXOcEeYXPegs4RmkM4t5vZbV+SUs3FDAwg2FrMrbj7WQlhDNGUMymDwknW8MTCc5TqPLRaTjUhKXI6upgI/vdV4YOP48J4lHJwQ6smO2v7KGD74sImd9AYs2FrK3ogZjYEzvFG47czCTj+/G8J5JhOl5bhEJEkri0rw1L8H/fgGl+TDiYjjz15DSO9BRtZi1lrU7S8nZUEDOhkKWb9+H10KXuEgmDU5n8pBufGNQOl3jowIdqohIqyiJS/Pyl0F8Glz8X+hzUqCjaZHSqlo+/rKIhb7EXVDmrL89KjOZmycPJHtIN0Znpmj2NBEJCUrickh5Abz/axg5w3lU7PRfOvORh3XcAV3WWjbuKXfuba8vYNlX+6jzWhJjIjhtcDqTj+/GpMHppCfqUTARCT1K4uLYuxken+ok8oyRThKPjAl0VM3yei3/W7ebe9/fRO6uUgCG9khi9mn9mTykG2N7p2h1MBEJeUriAoUb4PELwVsL173foR8Z83otb6/dzT/e/5L1u8vonxbP3ReN4MyhGXRP7rg/OkRE3KAk3tmV5MFj5wMGrn4Dug0NdERN8notb67ZxT/f38SGPWX0T4/n7zPHMHV0T93fFpFOS0m8s0vsCWMuhzFX+FYY61g8Xssbq3fxz/e/5MuCcgZ2S+DeS8dwwSglbxERJfHOaudKiE2BLn2dNbw7GI/X8vqqnfzj/S/ZXFjBoG4J/POysZw3soeSt4iIj5J4Z7RjCTx1MfQYBVe/HuhoDlPn8fLaqp38c8EmthRWMDgjgfsvH8e5I7prEhYRkUaUxDubrz6Fp2c4z39f9ECgozmozuPl1ZU7uW/hJrYWVTCkeyL/mjWOc4YreYuINEdJvDPZ+iHMnQlJPZ01v5N6Bjoi6jxeXl6Rz/0LN7FtbyVDeyTx4BXjOGuYkreIyNEoiXcW1jprf6f0hm/Ph8SMgIZT6/Hy8vJ87lu4ie3FlQzrkcS/rxzPlKEZSt4iIi2kJN4ZWOusNjbzSfB6nK70AKn1eHlxWR7352xiR/EBRvRK4j/fzuLMod0wQboimohIoCiJh7r1b8DyJ2DG4xDbJWBh1NR5ydlRy8//lEP+/gOMykzmzqnDOX2IkreISGspiYeyda/CC99xZmCrqwrYNKqfby3mtmdXkr+/htGZydx90Qiyj09X8hYRaSMl8VC1+gV4aTZkZsGsFyAmqd1DsNby34+2cs9b6zmuaxw/HB/N9y85RclbRMRPtEJEKFr9Arx0HRx3IlzxUkASeHl1HTc/s4K738jlzKHdePXmUxiVHqEELiLiR2qJh6JuQ2HYNJh2P0TFt/vlNxWUccNTy9lSWM6cc4dw/Wn9lbxFRFygJB5K8pZCr/GQMRxmPBaQEN5cvYvbn/+CmMhwnvruRE4eGLiR8CIioU7d6aHiswfh4TNg9fMBuXytx8vdr6/jxqeXM7h7Iq/fcqoSuIiIy1xtiRtjzgHuBcKBh621v290/G/AZN/HOKCbtTbFzZhC0sf/gHd/CUMugGEXtfvlC8qquPnpFXy+rZhvn9SHX5w/jKgI/T4UEXGba0ncGBMO3A9MAfKAJcaY+dbadfXnWGtva3D+94GxbsUTsj74Myz4DQyfDt/8D4RHtuvll2wr5sanl1NWVcvfZ47horG92vX6IiKdmZvNpQnAJmvtFmttDTAPmHaE8y8DnnExntBTkAsLfwsjvwXffLhdE3j942OXPfQZ8VHhvHLTKUrgIiLtzM3u9F7Ajgaf84CJTZ1ojOkD9AMWuBhP6Ok2FK55CzJPgLDwdrtsRXUdP31xFa+v2sWUYRn85VujSYpp3x4AEREBY611p2BjLgHOsdZe6/t8JTDRWntzE+f+FMi01n6/mbJmA7MBMjIyxs+bN8+VmAOpvLychISEo59oLf23PEFJ8lD2pk1wP7BGdpZ7uW9FFbsqLBcPjuS8fpGEtfDxsRbXMUipfsEv1Ouo+gWnyZMnL7PWZjV1zM2WeD7Qu8HnTN++plwK3NRcQdbah4CHALKysmx2drafQuw4cnJyaFG9Pv0X7HgJet0E7fx3eHP1Ln674AtiIiN56tqxnHKMo89bXMcgpfoFv1Cvo+oXetxM4kuAQcaYfjjJ+1Lg8sYnGWOGAF2AT12MJTTsXAnv3gHHnwdn/7bdLlvn8fKHt9fznw+3MqZ3Cg9cMY4eybHtdn0REWmaa0ncWltnjLkZeAfnEbNHrLVrjTF3AUuttfN9p14KzLNu9euHiupyePG7EJ/uzMTWTjOgFZRVcfPcFXy+tZgrT+zDLy4YSnRE+91/FxGR5rn6nLi19k3gzUb77mj0+U43YwgZa1+CvZvhqtcgrmu7XHLJtmJueno5pVW1/G3maKaPzWyX64qISMto2tVgMe7b0HMcdB/h+qWstTz68TZ+92YumV1iefw7Exjao/0XURERkSNTEu/o9n0FtZXO42TtkMAbPz725xmjSY7V42MiIh2RknhH5ql17oPv3w4/WAWRMa5ebnNhOTc8uYzNheXcfvbxfG/SAMLCtPqYiEhHpSTekeXcA3lL4JJHXE/gefsqmfnvz/Bay5PfnXjMj4+JiEj7UxLvqLYsgg//CmOvhBEXu3qp0qpavvPYEqrrPLz0vZMZlJHo6vVERMQ/tNRUR1SxF16aDakD4dw/uHqpWo+XG59azpbCCh68YrwSuIhIEFFLvCOKToBRM5yFTaLiXbuMtZafv7yajzYV8adLRqkLXUQkyCiJdzReD0REw1l3u36pf+Vs5rmleXz/9IHMyOp99C+IiEiHou70jmT3GvjXic7WZa+uzOdP72xg2pie/HDKYNevJyIi/qck3kGEearhhe9AVSkkdnf1Wku2FXP786s4oW8X/njJKEw7TeEqIiL+pe70DmLgpv9C0Ub49isQ79696a1FFcx+Yim9usTy0JVZmgddRCSIqSXeEax9hZ673oFTb4X+2a5dZl9FDd95bAkAj159Al3io1y7loiIuE9JvCNY8wKliYNg8s9du0RVrYfZTy4lf/8B/vPtLPqmuTfqXURE2oeSeEcw43FWj7wDwt2Zo9zrtfzkhVUs2baPv8wYTVbf9lkFTURE3KUkHkhfPAuluyAsnNoo91YJ++u7G5n/xU5uP/t4po7u6dp1RESkfSmJB8q2j+GVG+Cjv7p6meeW7OC+hZuYmdWbG7MHuHotERFpX0rigVBZDC9dB136whl3uHaZj74s4v9eXs03BqVx9/QRepRMRCTE6BGz9mYtzP8+lBfAte9CtDtzlW/cU8b3nlrGgPQE7p81jshw/V4TEQk1SuLtbeVcWP+6M61qz7GuXKKgrIprHl1CTFQ4j1xzAkkx7gyYExGRwFISb29DzoPyX8GJN7lS/IEaD9c9vpTiihqeu/4keqXEunIdEREJPCXx9lJbBSYMYrvAN37oyiU8XssP5q1gVX4JD12ZxcjMZFeuIyIiHYNulLaX//0cHjkL6qpdu8Tv3szlf+v2cMcFw5gyLMO164iISMegJN4ecl+HJQ9Dn1OcZUZd8MSn2/jvR1u5+uS+XHNKP1euISIiHYuSuNtK8uDVm6DHaDjjV65c4v3cPdw5fy1nDs3glxcMc+UaIiLS8SiJu8nrgZeuB08tXPwIRPh/wZE1+SV8/5kVDOuZxD8uG0N4mJ4FFxHpLJTE3VRRCJV74fw/Q9pAvxe/c/8BvvPYElJiI3nkqhOIi9I4RRGRzkT/6rspsTtcvwjC/d8CL6uq5TuPLaGyxsML3zuJbkkxfr+GiIh0bGqJu2XZY7B3szOQzc/TndZ5vNw8dwVfFpTzr1njGNLdvcVTRESk41ISd0NJHrz2A9jwlt+LttZyx/y1LNpYyG8vGsFpg9P9fg0REQkOSuJu2LzA2Q48w+9Fv5dbwNzF2/le9gAunXCc38sXEZHgoSTuhk3vQ2IPSB/i96Kf+HQbPZJj+NGUwX4vW0REgouSuL95PbAlBwac7vd74dv3VvLhl0VcesJxRGhVMhGRTk+ZwN+KvoSacieJ+9ncz7cTHmaYeUJvv5ctIiLBR4+Y+Vu3IfCTrRDu3+U/a+q8PL90B2cM6Ub3ZD1OJiIiLrfEjTHnGGM2GGM2GWPmNHPOt4wx64wxa40xc92Mp93EJEGkf5cAfWftbvZW1DDrxD5+LVdERIKXa0ncGBMO3A+cCwwDLjPGDGt0ziDgZ8Ap1trhwK1uxdMuqkrhsQtg6wd+L/rpxV/Ru2ss3xiY5veyRUQkOLnZEp8AbLLWbrHW1gDzgGmNzrkOuN9auw/AWlvgYjzu2/ah8zL+/bNuKijnsy3FXDbhOMI0N7qIiPgYa607BRtzCXCOtfZa3+crgYnW2psbnPMKsBE4BQgH7rTWvt1EWbOB2QAZGRnj582b50rMbTVo44Nk7FnIx6c8hQ07tnvi5eXlJCQkNHnsmdxq3ttex1+z40iODt4kfqQ6hgLVL/iFeh1Vv+A0efLkZdbarKaOBXpgWwQwCMgGMoEPjDEjrbX7G55krX0IeAggKyvLZmdnt3OYLfTFrTBgMpNOn3LMX83JyaGpelXVevjBovc5d2QPpp09zg9BBk5zdQwVql/wC/U6qn6hx83u9Hyg4bNQmb59DeUB8621tdbarTit8kEuxuSe4i2wb6vfHy17Y9UuSg7UcvlEzc4mIiKHczOJLwEGGWP6GWOigEuB+Y3OeQWnFY4xJg0YDGxxMSb3VJdD/8l+T+JzP99O/7R4Tuqf6tdyRUQk+LmWxK21dcDNwDtALvCctXatMeYuY8yFvtPeAfYaY9YBC4HbrbV73YrJVT1Gwbdf8eu64bm7Sln21T4un3gcxs+zv4mISPBz9Z64tfZN4M1G++5o8N4CP/S9gpenDqpLIa6rX4udu3g7URFhXDwu06/liohIaNC0q/6QtwT+2B82L/RbkRXVdby8Ip8LRvagS3yU38oVEZHQoSTuD5vfdxY76TnGb0W+9sVOyqvrNKBNRESa1aIkboz5gTEmyTj+a4xZbow5y+3ggsbmBdArC2K7+K3Ipxdv5/iMRMb38V+ZIiISWlraEv+OtbYUOAvoAlwJ/N61qIJJZTHkL/frqPRVeftZnV/CrBM1oE1ERJrX0iRen0nOA5601q5tsK9z27oIsDDwDL8VOXfxdmIjw7lobC+/lSkiIqGnpUl8mTHmfzhJ/B1jTCLgdS+sINJ7Ipz3Z+jpn9nUSqtqeXXlTi4c3ZOkGP8uZyoiIqGlpY+YfRcYA2yx1lYaY1KBa9wLK4gk9YQJ1/mtuFdX5HOg1sOsEzWgTUREjqylLfFpwOYGc5p7gP7uhBRE9u+Alc84S5D6gbWWpxdvZ0SvJEZlpvilTBERCV0tTeK/staW1H/wJfNfuRNSEFn/OrxyAxwo9ktxy7fvY/3uMmZN7OOX8kREJLS1NIk3dV6gV0ALvM0LoOsA6NLXL8U9vXg7CdERXDi6p1/KExGR0NbSJL7UGPNXY8wA3+uvwDI3A+vw6qph20d+G5VeXmN5fdUuLhrbk/ho/T4SEZGja2kS/z5QAzzre1UDN7kVVFDYsRhqK/32fPjHO+uoqfNy+QR1pYuISMu0qMlnra0A5rgcS3DJXw5hkdD31DYXZa1l4Y5axh2XwrCeSX4ITkREOoMjJnFjzN+ttbcaY14DbOPj1toLm/ha53DqrTBmFkQntrmoz7YUs7vC8uPz1AoXEZGWO1pL/Enf9s9uBxKUEtL9UszTi78iLgIuGNXDL+WJiEjncMQkbq1dZowJB2Zba2e1U0wdX+5rsOo5mHpvm9cQLyqv5p21u8nOjCAmMtxPAYqISGdw1IFt1loP0McYo0Wt661/wxmZHtP2CVmeX5pHrccyubemWBURkWPT0meZtgAfG2PmAxX1O621f3Ulqo7MWuf58AGTIaxty7F7vZZnPt/OxH5d6ZlQ7acARUSks2hpFtoMvO47P9H3SnArqA5tz1oo3wMD2v58+EebitheXMnlEzVPuoiIHLuWtsTXWWufb7jDGDPDhXg6vs0LnO2AyW0u6unFX9E1PopzRnTn04++bHN5IiLSubS0Jf6zFu4LfbFdYNg0Z/WyNthTWsV7uQXMyMokOkID2kRE5Ngd7Tnxc3HWEO9ljPlHg0NJQJ2bgXVY4650Xm307JIdeLyWy05QV7qIiLTO0brTdwJLgQs5fK70MuA2t4LqsA7sg8h4iGjbQP06j5dnPt/ONwal0Tct3k/BiYhIZ3O058S/AL4wxsz1nXuctXZDu0TWES36E3zxDPz4Swhv/SIlORsK2VVSxa+mDvNjcCIi0tm09J74OcBK4G0AY8wY3+NmncvmBdBjdJsSOMDcz7eTnhjNGUMz/BSYiIh0Ri1N4ncCE4D9ANbalUA/l2LqmEryoTC3zauW5e2rZOGGAi49oTeR4W17zlxERDq3lmaRWmttSaN9X1sQJaRtWehs25jE532+AwNcOkED2kREpG1a2i+81hhzORBujBkE3AJ84l5YHdDmBZCQARnDW11ErcfLs0t3kH18N3qlxPoxOBER6Yxa2hL/PjAcqAaeAUqBW90KqkM68SY4709gTKuLeG/dHgrLqpmlGdpERMQPWtQSt9ZWAj/3vTqnzPHA+DYV8fTi7fRMjiH7+G7+iUlERDq1o032csQR6NbaC/0bTge1eSFYDww8s9VFbCuq4KNNRfxwymDCw1rfmhcREal3tJb4ScAOnC70xUDnzD4f/BmqS9uUxJ/5fDvhYYaZJ/T2Y2AiItKZHe2eeHfg/4ARwL3AFKDIWrvIWrvI7eA6hOoy2PFZm0alV9d5eH5ZHmcO7UZGUowfgxMRkc7siEncWuux1r5trb0KOBHYBOQYY25uSeHGmHOMMRuMMZuMMXOaOH61MabQGLPS97q2VbVw07aPwFvXpiT+9prdFFfUMGtiHz8GJiIind1RB7YZY6KB84HLgL7AP4CXW/C9cOB+nNZ7HrDEGDPfWruu0anPWmtb9KMgIDa9D5FxcNyJrS7i6cXbOa5rHKcOTPNjYCIi0tkdbWDbEzhd6W8Cv7bWrjmGsicAm6y1W3xlzQOmAY2TeMe2cwX0PRUiolv19S/3lPH51mJ+es4QwjSgTURE/OhoLfErgArgB8At5tAz0gaw1tqkI3y3F86guHp5wMQmzrvYGHMasBG4zVq7o4lzAue77zqrl7XS3M+3ExlumJGV6cegREREwFjrzuypxphLgHOstdf6Pl8JTGzYdW6MSQXKrbXVxpjrgZnW2q/dfDbGzAZmA2RkZIyfN2+eKzH7W7XHctvCSkamhfO9MUce0FZeXk5CQkI7RRYYoV5H1S/4hXodVb/gNHny5GXW2qymjrVtOa4jywcaPk+V6dt3kLV2b4OPDwN/bKoga+1DwEMAWVlZNjs726+BNuutORCTDJN/1qqvP790B5V1q7h16gmcNCD1iOfm5OTQbvUKkFCvo+oX/EK9jqpf6HFzGa0lwCBjTD9jTBRwKXDY5DHGmB4NPl4I5LoYz7Hx1MHKuVCaf/RzmzH38+30T4/nxP5d/RiYiIiIw7WWuLW2zvco2jtAOPCItXatMeYuYKm1dj7OffYLgTqgGLjarXiO2c7lUF0CA89o1dfX7ixhxfb9/PKCYZg2zLcuIiLSHDe707HWvokzsr3hvjsavP8Z0Lq+ardteh9MGPSb1Kqvz128naiIMC4e18vPgYmIiDjc7E4PbpsXQM9xENe6rvD3cvcwZVgGKXFRfg5MRETE4WpLPGhZC92GQPrQVn19b3k1e0qrGZOZ4ufAREREDlESb4oxcOE/W/319bvLABjSI9FfEYmIiHyNutObUl7gtMZbKXdXKQBDexxpLhwREZG2URJvzFr4zxnw6k2tLiJ3VxnpidGkJbRuqlYREZGWUBJvbO9mKNkOvca1uojcXaUM6a6udBERcZeSeGObFzjbVi49WuvxsqmgnGHqShcREZcpiTe2eQF06Qdd+7fq61sKK6jxeHU/XEREXKck3lBdDWz7sNWtcDg0qE0j00VExG16xKyx6Q9CynGt/nrurlKiwsMYkB56K+mIiEjHoiTeUEQUDJ3apiJyd5cxsFsCkeHq5BAREXcp0zS0/Ako3NCmInJ3laorXURE2oWSeL2KIph/C6ybf/Rzm1FUXk1hWbVGpouISLtQEq+3JQewbRrUtn6XM92qRqaLiEh7UBKvt3kBxHaBnmNaXcTBkema6EVERNqBkjg4U61uXgD9syEsvNXF5O4upVtiNKmablVERNqBkjjA/u1QubdNXengzJk+RF3pIiLSTvSIGUCXPvDTbW0qoqbOy6aCMk4bnOafmERERI5CSbxeVHybvr6lqJxaj9XIdBERaTfqTq+tgkfPhy/fa1Mxhwa1KYmLiEj7UBLf/gl89RFYb5uKyd1VRlR4GP3T29aiFxERaSkl8c0LIDwK+p7SpmJyd5UyKEPTrYqISPtRxtm8EI47sc33xHN3lakrXURE2lXnTuJlu2HPmjY/WlZYVk1ReTVDNWe6iIi0o86dxKtKYdBZMPDMNhWzfrczqE0j00VEpD117kfM0gfDrOfbXMzBkelK4iIi0o46d0vcT3J3lZGRFE3X+KhAhyIiIp2Ikrgf5O4q1cplIiLS7pTE26imzsvmwnKNTBcRkXanJN5Gmwqc6VY1Ml1ERNqbkngbaWS6iIgEipJ4G+XuKiUqIox+aZpuVURE2peSeBvl7ipjcEYCEZpuVURE2pkyTxut313KUA1qExGRAHA1iRtjzjHGbDDGbDLGzDnCeRcbY6wxJsvNePytoKyKovIaTfIiIiIB4VoSN8aEA/cD5wLDgMuMMcOaOC8R+AGw2K1Y3JK7qwxAI9NFRCQg3GyJTwA2WWu3WGtrgHnAtCbO+w3wB6DKxVhcsd433aq600VEJBDcnDu9F7Cjwec8YGLDE4wx44De1to3jDG3N1eQMWY2MBsgIyODnJwc/0fbCjlfVNEl2vDFkk/aXFZ5eXmHqZdbQr2Oql/wC/U6qn6hJ2ALoBhjwoC/Alcf7Vxr7UPAQwBZWVk2Ozvb1dha6p4VHzCmbwzZ2RPaXFZOTg4dpV5uCfU6VAY5MwAAD0FJREFUqn7BL9TrqPqFHje70/OB3g0+Z/r21UsERgA5xphtwInA/GAZ3FZd52FzYbnmTBcRkYBxM4kvAQYZY/oZY6KAS4H59QettSXW2jRrbV9rbV/gM+BCa+1SF2Pym00F5f/f3r3HyFWedxz/Pr4ANjZgoDFgg01a146jUKBbSKM02AklhkTQmxpI2tKEChHFLVHUNkhIKEL9J0SNKlKalrS0tE3rhKZJaWVupbgXtaRcaq6zxMYlAjNrc5+1je9P/5izZVhm7N31zs45s9+PNNoz57wz8z46Y//2nPPue9h/MB2ZLknqma6FeGbuB9YC9wA14NuZ+VRE3BgRl3brc6fKyMj0lY5MlyT1SFeviWfmemD9qHU3dGi7qpt9mWyD9QZHz5rB0pOcblWS1BvO2DZBtaEGP75wvtOtSpJ6xgSagMykVh92khdJUk8Z4hPw0vAeXt2515HpkqSeMsQn4OliprYVztQmSeohQ3wC3hqZbohLknrHEJ+AwaEGpx1/DMfPnd3rrkiSpjFDfAJq9YaTvEiSes4QH6fmdKs7HZkuSeo5Q3ycNm3bwYGD6ch0SVLPGeLjVHNkuiSpJAzxcRocGuaY2TM482SnW5Uk9ZYhPk61eoPlC+czc0b0uiuSpGnOEB+H5nSrDU+lS5JKwRAfh+3De3ht1z5HpkuSSsEQH4eR6VYdmS5JKgNDfBwcmS5JKhNDfBwG68MsOmGO061KkkrBEB+HWr3h9XBJUmkY4mO0e98Btry801PpkqTSMMTHaPN2p1uVJJWLIT5Gb41M93S6JKkcDPExqtUbHDN7BktOcrpVSVI5GOJjNFgfZvkpxzndqiSpNAzxMchMakMNVnoqXZJUIob4GAw1dvP6rn2OTJcklYohPgaD9WHA6VYlSeViiI/ByMj0FZ5OlySViCE+BrV6g0UnzOG4Y5xuVZJUHob4GAwODXsqXZJUOob4Yezed4AtL+1wZLokqXQM8cP4wbZhDias8EhcklQyhvhhODJdklRWhvhhPF1vMGf2TJacOLfXXZEk6W26GuIRsSYinomIzRFxXZvt10TEExGxMSL+IyJWdrM/E1GrN1h+ynxmON2qJKlkuhbiETETuAW4GFgJXNEmpP8mM9+XmWcDNwFf7VZ/JiIzHZkuSSqtbh6JnwdszswtmbkXWAdc1togMxstT48Fsov9Gbf6G7t54819jkyXJJXSrC6+9yLg+ZbnLwDnj24UEZ8DvgAcBXy4i/0Zt9r/z9TmkbgkqXwiszsHvxHxS8CazPyN4vmvAudn5toO7T8JfDQzr2yz7WrgaoCFCxf+5Lp167rS59H+8dm9fGfTPv7oI3OZO7u718R37NjBvHnzuvoZvdbvNVpf9fV7jdZXTatXr34kMwfabevmkfhW4PSW54uLdZ2sA77ebkNm3grcCjAwMJCrVq2apC4e2h0vPsriBa9zyc+u7vpnbdiwgamqq1f6vUbrq75+r9H6+k83r4k/BCyLiDMj4ijgcuDO1gYRsazl6ceATV3sz7jV6g0HtUmSSqtrR+KZuT8i1gL3ADOB2zLzqYi4EXg4M+8E1kbEhcA+4DXgHafSe+XNvQd47uWdfPys03rdFUmS2urm6XQycz2wftS6G1qWr+3m5x+JkelW33OKI9MlSeXkjG0djIxM93S6JKmsDPEOBoeGmXvUTM5wulVJUkkZ4h087XSrkqSSM8TbyEwGHZkuSSo5Q7yNF9/YTWP3fkNcklRqhngbtReLQW2OTJcklZgh3sbgkHOmS5LKzxBvo1Yf5owT5zLv6K7+Gb0kSUfEEG+jVm+wwlPpkqSSM8RHeXPvAf73lZ0OapMklZ4hPsoz24bJdKY2SVL5GeKjvDXdqqfTJUnlZoiPMlhvcOxRMzl9gdOtSpLKzRAfpVYfZsWpxzndqiSp9AzxFplJbciR6ZKkajDEW2x9/U2GnW5VklQRhniLWn0YcGS6JKkaDPEWIyPTl3s6XZJUAYZ4i8GhBktOcrpVSVI1GOItavVh3nOKp9IlSdVgiBd27d3Pc6/sZIWTvEiSKsIQLzwz5HSrkqRqMcQLIyPTVxrikqSKMMQLtXqDeUfPYtEJc3rdFUmSxsQQLwwWM7U53aokqSoMcZrTrQ7Wh70eLkmqFEMceOG1Nxnes9+R6ZKkSjHEab2HuEfikqTqMMRpjkyPgOULPRKXJFWHIU7zSHzJiXM51ulWJUkVYojTHJnuqXRJUtVM+xDfuWc/P3x1lyEuSaqcaR/ig8V0qyu8/agkqWIM8SFHpkuSqqmrIR4RayLimYjYHBHXtdn+hYh4OiIej4j7I2JJN/vTTq3eYP7Rs1i8wOlWJUnV0rUQj4iZwC3AxcBK4IqIWDmq2f8AA5l5FvB3wE3d6k8ntfowK06dT4TTrUqSqqWbR+LnAZszc0tm7gXWAZe1NsjMBzJzV/H0QWBxF/vzDgcPJs8MOd2qJKmauvmH0YuA51uevwCcf4j2VwF3tdsQEVcDVwMsXLiQDRs2TEoHt+86yI49+5nRqLNhw8uT8p4TtWPHjkmrq6z6vUbrq75+r9H6+k8pZjeJiF8BBoAL2m3PzFuBWwEGBgZy1apVk/K5dz85BDzCZRcMcM4ZCyblPSdqw4YNTFZdZdXvNVpf9fV7jdbXf7oZ4luB01ueLy7WvU1EXAhcD1yQmXu62J93OHrWDH5q6QKW++dlkqQK6maIPwQsi4gzaYb35cAnWxtExDnAnwBrMnN7F/vS1uoV72L1indN9cdKkjQpujawLTP3A2uBe4Aa8O3MfCoiboyIS4tmXwHmAXdExMaIuLNb/ZEkqd909Zp4Zq4H1o9ad0PL8oXd/HxJkvrZtJ+xTZKkqjLEJUmqKENckqSKMsQlSaooQ1ySpIoyxCVJqihDXJKkijLEJUmqKENckqSKMsQlSaooQ1ySpIqKzOx1H8YlIl4CftjrfnTBycDLve5El/V7jdZXff1eo/VV05LM/JF2GyoX4v0qIh7OzIFe96Ob+r1G66u+fq/R+vqPp9MlSaooQ1ySpIoyxMvj1l53YAr0e43WV339XqP19RmviUuSVFEeiUuSVFGG+BSKiNMj4oGIeDoinoqIa9u0WRURb0TExuJxQy/6OlER8VxEPFH0/eE22yMibo6IzRHxeESc24t+TlRELG/ZNxsjohERnx/VplL7MCJui4jtEfFky7oTI+K+iNhU/FzQ4bVXFm02RcSVU9fr8elQ41ciYrD4Hn43Ik7o8NpDfqfLoEN9X4qIrS3fw0s6vHZNRDxT/Ju8bup6PXYd6vtWS23PRcTGDq8t/f47IpnpY4oewKnAucXyfOAHwMpRbVYB/9Trvh5Bjc8BJx9i+yXAXUAA7we+3+s+H0GtM4Ehmn/DWdl9CHwIOBd4smXdTcB1xfJ1wJfbvO5EYEvxc0GxvKDX9YyjxouAWcXyl9vVWGw75He6DI8O9X0J+O3DvG4m8CzwbuAo4LHR/yeV4dGuvlHbfx+4oar770geHolPocysZ+ajxfIwUAMW9bZXU+4y4C+z6UHghIg4tdedmqCPAM9mZqUnH8rMfwNeHbX6MuD2Yvl24OfavPSjwH2Z+WpmvgbcB6zpWkePQLsaM/PezNxfPH0QWDzlHZskHfbhWJwHbM7MLZm5F1hHc9+XyqHqi4gAfhn42yntVEkY4j0SEUuBc4Dvt9n80xHxWETcFRHvndKOHbkE7o2IRyLi6jbbFwHPtzx/ger+InM5nf/jqPI+BFiYmfVieQhY2KZNP+3Lz9A8Q9TO4b7TZba2uFxwW4dLIv2wD38G2JaZmzpsr/L+OyxDvAciYh7wHeDzmdkYtflRmqdnfwL4GvC9qe7fEfpgZp4LXAx8LiI+1OsOdUNEHAVcCtzRZnPV9+HbZPOcZN/+GUtEXA/sB77ZoUlVv9NfB34UOBuo0zzl3I+u4NBH4VXdf2NiiE+xiJhNM8C/mZl/P3p7ZjYyc0exvB6YHREnT3E3JywztxY/twPfpXm6rtVW4PSW54uLdVVzMfBoZm4bvaHq+7CwbeQyR/Fze5s2ld+XEfHrwMeBTxW/rLzDGL7TpZSZ2zLzQGYeBL5B+35Xeh9GxCzgF4BvdWpT1f03Vob4FCqu3fwZUMvMr3Zoc0rRjog4j+Y+emXqejlxEXFsRMwfWaY5cOjJUc3uBH6tGKX+fuCNltO2VdLxt/8q78MWdwIjo82vBP6hTZt7gIsiYkFxqvaiYl0lRMQa4HeBSzNzV4c2Y/lOl9KosSY/T/t+PwQsi4gzi7NLl9Pc91VxITCYmS+021jl/TdmvR5ZN50ewAdpnpZ8HNhYPC4BrgGuKdqsBZ6iOUr0QeADve73OOp7d9Hvx4oari/Wt9YXwC00R8Q+AQz0ut8TqPNYmqF8fMu6yu5Dmr+M1IF9NK+JXgWcBNwPbAL+GTixaDsA/GnLaz8DbC4en+51LeOscTPN68Ej/xb/uGh7GrC+WG77nS7bo0N9f1X8G3ucZjCfOrq+4vklNP9S5tkq1Ves/4uRf3ctbSu3/47k4YxtkiRVlKfTJUmqKENckqSKMsQlSaooQ1ySpIoyxCVJqihDXJoGIuLAqLuvTdrdqiJiaevdpSRNnVm97oCkKfFmZp7d605ImlweiUvTWHGv5ZuK+y3/d0T8WLF+aUT8S3HzjPsj4oxi/cLi3tuPFY8PFG81MyK+ERFPRcS9ETGnaP9bEfF08T7relSm1LcMcWl6mDPqdPonWra9kZnvA/4Q+INi3deA2zPzLJo3Brm5WH8z8K/ZvLnLuTRnwQJYBtySme8FXgd+sVh/HXBO8T7XdKs4abpyxjZpGoiIHZk5r83654APZ+aW4uY8Q5l5UkS8THOazn3F+npmnhwRLwGLM3NPy3sspXlf8WXF8y8CszPz9yLibmAHzTu5fS+LG8NImhweiUvKDsvjsadl+QBvjbf5GM258s8FHiruOiVpkhjikj7R8vO/iuX/pHlHK4BPAf9eLN8PfBYgImZGxPGd3jQiZgCnZ+YDwBeB44F3nA2QNHH+VixND3MiYmPL87szc+TPzBZExOM0j6avKNb9JvDnEfE7wEvAp4v11wK3RsRVNI+4P0vz7lLtzAT+ugj6AG7OzNcnrSJJXhOXprPimvhAZr7c675IGj9Pp0uSVFEeiUuSVFEeiUuSVFGGuCRJFWWIS5JUUYa4JEkVZYhLklRRhrgkSRX1f51eu/uyioXIAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 20/20 [00:00<00:00, 372.78it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "==================================================================\n",
            "\n",
            "\rEPOCH: 20.000\ttrn_loss: 0.094\ttrn_acc: 0.969\tval_loss: 0.093\tval_acc: 0.969\t(8106.35s - 0.00s remaining)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 20/20 [00:00<00:00, 330.28it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "==================================================================\n",
            "\n",
            "\rEPOCH: 20.000\ttrn_loss: 0.146\ttrn_acc: 0.952\tval_loss: 0.202\tval_acc: 0.938\t(7348.78s - 0.00s remaining)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "==================================================================\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6lObvfj4Z3Zw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}